"""
模板服务
负责管理文档转换模板的创建、更新、删除和应用
"""

import os
import json
import logging
from typing import Dict, Any, Optional, List
from datetime import datetime
from ..models.template import Template
from ..models.history import History
from ..utils.validation_utils import ValidationUtils

logger = logging.getLogger(__name__)

class TemplateService:
    """模板服务类"""
    
    def __init__(self, app=None):
        self.app = app
        self.template_dir = app.config.get('TEMPLATE_DIR', 'templates') if app else 'templates'
        
        # 确保模板目录存在
        os.makedirs(self.template_dir, exist_ok=True)
    
    def create_template(self, user_id: str, template_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        创建新模板
        
        Args:
            user_id: 用户ID
            template_data: 模板数据
            
        Returns:
            创建结果
        """
        try:
            # 验证模板数据
            validation_result = self._validate_template_data(template_data)
            if not validation_result['valid']:
                return {
                    'success': False,
                    'error': validation_result['error']
                }
            
            # 检查模板名称唯一性
            existing_template = Template.find_by_name(template_data['name'])
            if existing_template:
                return {
                    'success': False,
                    'error': '模板名称已存在'
                }
            
            # 准备模板数据
            template_record = {
                'name': template_data['name'],
                'description': template_data.get('description', ''),
                'type': template_data.get('type', Template.TYPE_CUSTOM),
                'format': template_data.get('format', Template.FORMAT_ALL),
                'config': template_data.get('config', {}),
                'content': template_data.get('content', ''),
                'created_by': user_id,
                'is_active': True,
                'is_default': False,
                'usage_count': 0,
                'rating': 0.0,
                'created_at': datetime.utcnow(),
                'updated_at': datetime.utcnow()
            }
            
            # 创建模板记录
            template_id = Template.create(template_record)
            
            # 保存模板文件
            if template_data.get('content'):
                self._save_template_file(template_id, template_data['content'])
            
            logger.info(f"模板创建成功: {template_id} - {template_data['name']}")
            
            return {
                'success': True,
                'template_id': template_id,
                'name': template_data['name']
            }
            
        except Exception as e:
            logger.error(f"模板创建失败: {str(e)}")
            return {
                'success': False,
                'error': f'模板创建失败: {str(e)}'
            }
    
    def update_template(self, template_id: str, user_id: str, update_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        更新模板
        
        Args:
            template_id: 模板ID
            user_id: 用户ID
            update_data: 更新数据
            
        Returns:
            更新结果
        """
        try:
            # 获取模板
            template = Template.find_by_id(template_id)
            if not template:
                return {'success': False, 'error': '模板不存在'}
            
            # 验证权限
            if template['created_by'] != user_id:
                return {'success': False, 'error': '无权限修改此模板'}
            
            # 验证更新数据
            if 'name' in update_data:
                existing_template = Template.find_by_name(update_data['name'])
                if existing_template and existing_template['_id'] != template_id:
                    return {'success': False, 'error': '模板名称已存在'}
            
            # 准备更新数据
            update_fields = {}
            
            for field in ['name', 'description', 'type', 'format', 'config']:
                if field in update_data:
                    update_fields[field] = update_data[field]
            
            if update_fields:
                update_fields['updated_at'] = datetime.utcnow()
                Template.update_by_id(template_id, update_fields)
            
            # 更新模板文件
            if 'content' in update_data:
                self._save_template_file(template_id, update_data['content'])
            
            logger.info(f"模板更新成功: {template_id}")
            
            return {'success': True, 'template_id': template_id}
            
        except Exception as e:
            logger.error(f"模板更新失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def delete_template(self, template_id: str, user_id: str) -> Dict[str, Any]:
        """
        删除模板
        
        Args:
            template_id: 模板ID
            user_id: 用户ID
            
        Returns:
            删除结果
        """
        try:
            # 获取模板
            template = Template.find_by_id(template_id)
            if not template:
                return {'success': False, 'error': '模板不存在'}
            
            # 验证权限
            if template['created_by'] != user_id:
                return {'success': False, 'error': '无权限删除此模板'}
            
            # 检查是否为默认模板
            if template.get('is_default'):
                return {'success': False, 'error': '无法删除默认模板'}
            
            # 删除模板文件
            self._delete_template_file(template_id)
            
            # 删除模板记录
            Template.delete_by_id(template_id)
            
            logger.info(f"模板删除成功: {template_id}")
            
            return {'success': True, 'template_id': template_id}
            
        except Exception as e:
            logger.error(f"模板删除失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def get_template(self, template_id: str) -> Dict[str, Any]:
        """
        获取模板详情
        
        Args:
            template_id: 模板ID
            
        Returns:
            模板信息
        """
        try:
            template = Template.find_by_id(template_id)
            if not template:
                return {'success': False, 'error': '模板不存在'}
            
            # 加载模板内容
            content = self._load_template_file(template_id)
            if content:
                template['content'] = content
            
            return {'success': True, 'template': template}
            
        except Exception as e:
            logger.error(f"获取模板失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def list_templates(self, template_type: Optional[str] = None, 
                      format_filter: Optional[str] = None,
                      active_only: bool = True,
                      limit: int = 50, offset: int = 0) -> Dict[str, Any]:
        """
        获取模板列表
        
        Args:
            template_type: 模板类型过滤
            format_filter: 格式过滤
            active_only: 仅显示活跃模板
            limit: 返回数量限制
            offset: 偏移量
            
        Returns:
            模板列表
        """
        try:
            templates = Template.list_templates(
                template_type=template_type,
                format_filter=format_filter,
                active_only=active_only,
                limit=limit,
                offset=offset
            )
            
            total = Template.count_templates(
                template_type=template_type,
                format_filter=format_filter,
                active_only=active_only
            )
            
            return {
                'success': True,
                'templates': templates,
                'total': total,
                'limit': limit,
                'offset': offset
            }
            
        except Exception as e:
            logger.error(f"获取模板列表失败: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def get_default_templates(self) -> Dict[str, Any]:
        """
        获取默认模板列表
        
        Returns:
            默认模板列表
        """
        try:
            templates = Template.get_default_templates()
            
            return {
                'success': True,
                'templates': templates
            }
            
        except Exception as e:
            logger.error(f"获取默认模板失败: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def set_default_template(self, template_id: str, template_type: str) -> Dict[str, Any]:
        """
        设置默认模板
        
        Args:
            template_id: 模板ID
            template_type: 模板类型
            
        Returns:
            设置结果
        """
        try:
            # 验证模板存在
            template = Template.find_by_id(template_id)
            if not template:
                return {'success': False, 'error': '模板不存在'}
            
            # 设置为默认模板
            result = Template.set_as_default(template_id, template_type)
            
            if result:
                logger.info(f"设置默认模板成功: {template_id} - {template_type}")
                return {'success': True, 'template_id': template_id}
            else:
                return {'success': False, 'error': '设置默认模板失败'}
            
        except Exception as e:
            logger.error(f"设置默认模板失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def use_template(self, template_id: str, user_id: str) -> Dict[str, Any]:
        """
        使用模板（记录使用次数）
        
        Args:
            template_id: 模板ID
            user_id: 用户ID
            
        Returns:
            使用结果
        """
        try:
            # 验证模板存在
            template = Template.find_by_id(template_id)
            if not template:
                return {'success': False, 'error': '模板不存在'}
            
            # 更新使用次数
            Template.increment_usage(template_id)
            
            # 记录使用历史
            History.record_template_usage(user_id, template_id, template['name'])
            
            logger.debug(f"模板使用记录: {template_id} by {user_id}")
            
            return {'success': True, 'template_id': template_id}
            
        except Exception as e:
            logger.error(f"记录模板使用失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def rate_template(self, template_id: str, user_id: str, rating: float) -> Dict[str, Any]:
        """
        评价模板
        
        Args:
            template_id: 模板ID
            user_id: 用户ID
            rating: 评分 (1.0-5.0)
            
        Returns:
            评价结果
        """
        try:
            # 验证评分
            if not (1.0 <= rating <= 5.0):
                return {'success': False, 'error': '评分必须在1.0-5.0之间'}
            
            # 验证模板存在
            template = Template.find_by_id(template_id)
            if not template:
                return {'success': False, 'error': '模板不存在'}
            
            # 更新评分
            Template.update_rating(template_id, rating)
            
            logger.info(f"模板评价: {template_id} - {rating} by {user_id}")
            
            return {'success': True, 'template_id': template_id, 'rating': rating}
            
        except Exception as e:
            logger.error(f"模板评价失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def get_template_statistics(self) -> Dict[str, Any]:
        """
        获取模板统计信息
        
        Returns:
            统计信息
        """
        try:
            stats = Template.get_statistics()
            
            return {'success': True, 'statistics': stats}
            
        except Exception as e:
            logger.error(f"获取模板统计失败: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def _validate_template_data(self, template_data: Dict[str, Any]) -> Dict[str, Any]:
        """验证模板数据"""
        if not template_data.get('name'):
            return {'valid': False, 'error': '模板名称不能为空'}
        
        if not ValidationUtils.validate_template_name(template_data['name']):
            return {'valid': False, 'error': '模板名称格式不正确'}
        
        template_type = template_data.get('type', Template.TYPE_CUSTOM)
        if template_type not in [Template.TYPE_SYSTEM, Template.TYPE_CUSTOM]:
            return {'valid': False, 'error': '无效的模板类型'}
        
        template_format = template_data.get('format', Template.FORMAT_ALL)
        valid_formats = [Template.FORMAT_ALL, Template.FORMAT_PDF, Template.FORMAT_DOCX, 
                        Template.FORMAT_HTML, Template.FORMAT_EPUB]
        if template_format not in valid_formats:
            return {'valid': False, 'error': '无效的模板格式'}
        
        # 验证配置
        config = template_data.get('config', {})
        if not isinstance(config, dict):
            return {'valid': False, 'error': '模板配置必须是字典格式'}
        
        return {'valid': True}
    
    def _save_template_file(self, template_id: str, content: str) -> bool:
        """保存模板文件"""
        try:
            file_path = os.path.join(self.template_dir, f"{template_id}.html")
            
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(content)
            
            return True
            
        except Exception as e:
            logger.error(f"保存模板文件失败 {template_id}: {str(e)}")
            return False
    
    def _load_template_file(self, template_id: str) -> Optional[str]:
        """加载模板文件"""
        try:
            file_path = os.path.join(self.template_dir, f"{template_id}.html")
            
            if not os.path.exists(file_path):
                return None
            
            with open(file_path, 'r', encoding='utf-8') as f:
                return f.read()
            
        except Exception as e:
            logger.error(f"加载模板文件失败 {template_id}: {str(e)}")
            return None
    
    def _delete_template_file(self, template_id: str) -> bool:
        """删除模板文件"""
        try:
            file_path = os.path.join(self.template_dir, f"{template_id}.html")
            
            if os.path.exists(file_path):
                os.remove(file_path)
            
            return True
            
        except Exception as e:
            logger.error(f"删除模板文件失败 {template_id}: {str(e)}")
            return False
    
    def import_template(self, template_file_path: str, user_id: str) -> Dict[str, Any]:
        """
        导入模板
        
        Args:
            template_file_path: 模板文件路径
            user_id: 用户ID
            
        Returns:
            导入结果
        """
        try:
            if not os.path.exists(template_file_path):
                return {'success': False, 'error': '模板文件不存在'}
            
            # 读取模板文件
            with open(template_file_path, 'r', encoding='utf-8') as f:
                template_content = f.read()
            
            # 解析模板元数据（假设在文件头部有JSON格式的元数据）
            lines = template_content.split('\n')
            metadata = {}
            content_start = 0
            
            if lines[0].strip().startswith('<!--') and 'metadata' in lines[0]:
                # 查找元数据结束位置
                for i, line in enumerate(lines[1:], 1):
                    if line.strip().endswith('-->'):
                        try:
                            metadata_str = '\n'.join(lines[1:i])
                            metadata = json.loads(metadata_str)
                            content_start = i + 1
                        except json.JSONDecodeError:
                            pass
                        break
            
            # 提取模板内容
            template_html = '\n'.join(lines[content_start:])
            
            # 准备模板数据
            template_data = {
                'name': metadata.get('name', os.path.basename(template_file_path)),
                'description': metadata.get('description', '导入的模板'),
                'type': Template.TYPE_CUSTOM,
                'format': metadata.get('format', Template.FORMAT_ALL),
                'config': metadata.get('config', {}),
                'content': template_html
            }
            
            # 创建模板
            return self.create_template(user_id, template_data)
            
        except Exception as e:
            logger.error(f"导入模板失败: {str(e)}")
            return {'success': False, 'error': str(e)}
    
    def export_template(self, template_id: str, export_path: str) -> Dict[str, Any]:
        """
        导出模板
        
        Args:
            template_id: 模板ID
            export_path: 导出路径
            
        Returns:
            导出结果
        """
        try:
            # 获取模板
            template_result = self.get_template(template_id)
            if not template_result['success']:
                return template_result
            
            template = template_result['template']
            
            # 准备元数据
            metadata = {
                'name': template['name'],
                'description': template.get('description', ''),
                'type': template.get('type'),
                'format': template.get('format'),
                'config': template.get('config', {}),
                'exported_at': datetime.utcnow().isoformat()
            }
            
            # 生成导出内容
            export_content = f"<!-- metadata\n{json.dumps(metadata, indent=2, ensure_ascii=False)}\n-->\n"
            export_content += template.get('content', '')
            
            # 保存到文件
            with open(export_path, 'w', encoding='utf-8') as f:
                f.write(export_content)
            
            logger.info(f"模板导出成功: {template_id} -> {export_path}")
            
            return {'success': True, 'export_path': export_path}
            
        except Exception as e:
            logger.error(f"导出模板失败 {template_id}: {str(e)}")
            return {'success': False, 'error': str(e)}